home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Hardware / BetaScan / BetaScanDev / TestSrc / makeILBM.c next >
Encoding:
C/C++ Source or Header  |  1999-01-23  |  12.9 KB  |  501 lines
  1. /************************************************************************/
  2. /*                                                                      */
  3. /* Write image as ilbm                                                  */
  4. /*                                                                      */
  5. /*                                                                      */
  6. /*                                                                      */
  7. /*                                                                      */
  8. /************************************************************************/
  9.  
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13.  
  14. #include <exec/types.h>
  15. #include <datatypes/pictureclass.h>
  16.  
  17. #include <scanner.h>
  18. #include <MakeILBM.h>
  19. #include <packer.h>
  20.  
  21. #define ID_XBMI MAKE_ID('X','B','M','I')
  22. #define ILBM_BUFLEN 1500000
  23.  
  24. struct ImageBuf
  25. {
  26.   UBYTE* buf;
  27.   ULONG  actualLen;
  28.   FILE*  fh;
  29. };
  30.  
  31. struct ILBMFile
  32. {
  33.   char* fileName;
  34.   int   formLenOffset;
  35.   int   bodyLenOffset;
  36.   UBYTE flags;
  37.   
  38.   UBYTE depth;
  39.   UWORD width;
  40.   UWORD height;
  41.   UWORD xdpi;
  42.   UWORD ydpi;
  43.  
  44.   LineFormat format;
  45.  
  46.   ULONG scanLineWidth;
  47.   ULONG bufLen;
  48.   struct ImageBuf buf[3];
  49. };
  50.  
  51. #define ILBMFLAGS_COMPRESS  (0x01 << 0)
  52. #define ILBMFLAGS_TEMPFILE  (0x01 << 1)
  53.  
  54. struct xbmi
  55. {
  56.   WORD xbmi_type;   /* ILBM_PAL, ILBM_RGB, ... (se below) */
  57.   WORD xbmi_xdpi;
  58.   WORD xbmi_ydpi;
  59. };
  60.  
  61.  
  62. #define ILBM_PAL        0       /* BODY data = indexes into the palette (CMAP)
  63.                                  * numcolors = 1<<depth;
  64.                                  */
  65.  
  66. #define ILBM_GREY       1       /* BODY =  grayscale values
  67.                                  * Bits per sample = number of bitplanes.
  68.                                  * Samples per pixel = 1.
  69.                                  * black = 0, white = (1<<depth)-1;
  70.                                  */
  71.  
  72. #define ILBM_RGB        2       /* BODY data = red, green, and blue values.
  73.                                  * Bits per sample = depth/3.
  74.                                  * Samples per pixel = 3.
  75.                                  */
  76.  
  77. #define ILBM_RGBA       3       /* BODY data = red, green, blue, and alpha
  78.                                  * channel values.
  79.                                  * Bits per sample = depth/4.
  80.                                  * Samples per pixel = 4.
  81.                                  */
  82.  
  83. #define ILBM_CMYK       4       /* BODY data = cyan, magenta, yellow, and black
  84.                                  * values.
  85.                                  * Bits per sample = depth/4.
  86.                                  * Samples per pixel = 4.
  87.                                  */
  88.  
  89. #define ILBM_CMYKA      5       /* BODY data = cyan, magenta, yellow, black,
  90.                                  * and alpha channel values.
  91.                                  * Bits per sample = depth/5.
  92.                                  * Samples per pixel = 5.
  93.                                  */
  94.  
  95. #define ILBM_BW         6       /* BODY data = black and white bits.
  96.                                  * Bits per sample = 1.
  97.                                  * Samples per pixel = 1.
  98.                                  * white = 0, black = 1.
  99.                                  */
  100.  
  101. static char* tempfile[3] = {"ram:temp.red","ram:temp.green","ram:temp.blue"};
  102.  
  103. static void makePlane(UBYTE* source,UBYTE* dest,int bit,int pixelPerLine,int bytesPerPixel)
  104. {
  105.   int   bitNum,byteNum,offset;
  106.   UBYTE b,sourceMask;
  107.  
  108.   offset = bit/8;
  109.   bit %= 8;
  110.   
  111.   sourceMask = 0x01 << bit;
  112.   
  113.   source += offset;
  114.   for( byteNum = 0 ; byteNum < pixelPerLine ; byteNum++ )
  115.   {
  116.     UBYTE destMask;
  117.     
  118.     destMask = 0x80;
  119.     b = 0;
  120.     for( bitNum = 0 ; bitNum < 8 ; bitNum++ )
  121.     {
  122.       if( (*source) & sourceMask )
  123.         b |= destMask;
  124.  
  125.       destMask >>= 1;
  126.       source += bytesPerPixel;
  127.     }
  128.     *(dest++) = b;
  129.   }
  130. } 
  131.  
  132. static void makeILBM(struct ILBMFile* ilbmfh)
  133. {
  134.   struct BitMapHeader BMHD;
  135.   struct xbmi         XBMI;
  136.   FILE*  fh;
  137.   int    c;
  138.   
  139.   if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  140.   {
  141.     for( c = 0 ; c < 3 ; c++ )
  142.     {
  143.       if( ilbmfh->buf[c].fh && (ilbmfh->buf[c].fh = fopen(tempfile[c],"r")) )
  144.         setvbuf(ilbmfh->buf[c].fh,ilbmfh->buf[c].buf,_IOFBF,ilbmfh->bufLen);
  145.     }
  146.   }
  147.   
  148.   BMHD.bmh_Width = ilbmfh->width;
  149.   BMHD.bmh_Height = ilbmfh->height;
  150.   BMHD.bmh_Left = 0;
  151.   BMHD.bmh_Top = 0;
  152.   BMHD.bmh_Depth = ilbmfh->depth;
  153.   BMHD.bmh_Masking = 0;
  154.   BMHD.bmh_Pad = 0;
  155.   BMHD.bmh_Transparent = 0;
  156.   BMHD.bmh_XAspect = 1;
  157.   BMHD.bmh_YAspect = 1;
  158.   BMHD.bmh_PageWidth = ilbmfh->width;
  159.   BMHD.bmh_PageHeight = ilbmfh->height;
  160.   
  161.   switch( ilbmfh->depth )
  162.   {
  163.     case 1:
  164.       XBMI.xbmi_type = ILBM_BW;
  165.       break;
  166.     case 8:
  167.       XBMI.xbmi_type = ILBM_GREY;
  168.       break;
  169.     case 24:
  170.       XBMI.xbmi_type = ILBM_RGB;
  171.       break;
  172.   }        
  173.   XBMI.xbmi_xdpi = ilbmfh->xdpi;
  174.   XBMI.xbmi_ydpi = ilbmfh->ydpi;
  175.  
  176.   if( fh = fopen(ilbmfh->fileName,"w") )
  177.   {
  178.     int scanLine,color,bitNum;
  179.     ULONG lineLen,bodyLen,formLen;
  180.     ULONG temp,psize;
  181.     UBYTE *line;
  182.     UBYTE *pline = NULL;
  183.     UBYTE *scanbuf = NULL;
  184.  
  185.     lineLen = ((ilbmfh->width+7)/8+1) & 0xFFFFFFFE; // Number of bits in each plane row
  186.                                                     // Rounded up to an even number of words
  187.     line = malloc(ilbmfh->format==FORMAT_RGB?3*lineLen:lineLen);
  188.     if( (ilbmfh->flags & ILBMFLAGS_COMPRESS) && (pline = malloc(ilbmfh->format==FORMAT_RGB?6*lineLen:lineLen*2)) )
  189.       BMHD.bmh_Compression = 1;
  190.     else
  191.       BMHD.bmh_Compression = 0;
  192.       
  193.     temp = ID_FORM;
  194.     fwrite(&temp,4,1,fh);
  195.     ilbmfh->formLenOffset = ftell(fh);
  196.     temp = 0;
  197.     fwrite(&temp,4,1,fh);
  198.  
  199.     temp = ID_ILBM;
  200.     fwrite(&temp,4,1,fh);
  201.  
  202.     temp = ID_BMHD;
  203.     fwrite(&temp,4,1,fh);
  204.     temp = sizeof(struct BitMapHeader);
  205.     fwrite(&temp,4,1,fh);
  206.     fwrite(&BMHD,sizeof(struct BitMapHeader),1,fh);
  207.     
  208.     temp = ID_XBMI;
  209.     fwrite(&temp,4,1,fh);
  210.     temp = sizeof(struct xbmi);
  211.     
  212.     fwrite(&temp,4,1,fh);
  213.     fwrite(&XBMI,sizeof(struct xbmi),1,fh);
  214.  
  215.     if( ilbmfh->depth == 1 )
  216.     {
  217.       UBYTE b;
  218.       
  219.       temp = ID_CMAP;
  220.       fwrite(&temp,4,1,fh);
  221.       temp = 3*2;;
  222.       fwrite(&temp,4,1,fh);
  223.  
  224.       b = 0xFF;
  225.       fwrite(&b,1,1,fh);
  226.       fwrite(&b,1,1,fh);
  227.       fwrite(&b,1,1,fh);
  228.  
  229.       b = 0;
  230.       fwrite(&b,1,1,fh);
  231.       fwrite(&b,1,1,fh);
  232.       fwrite(&b,1,1,fh);
  233.     }
  234.     else if( ilbmfh->depth == 8 )
  235.     {
  236.       UBYTE b;
  237.       int   i;
  238.       
  239.       temp = ID_CMAP;
  240.       fwrite(&temp,4,1,fh);
  241.       temp = 3*256;;
  242.       fwrite(&temp,4,1,fh);
  243.       for( i = 0 ;  i < 256 ; i++ )
  244.       {
  245.         b = (UBYTE)i;
  246.         fwrite(&b,1,1,fh);
  247.         fwrite(&b,1,1,fh);
  248.         fwrite(&b,1,1,fh);
  249.       }
  250.     }
  251.     
  252.     temp = ID_BODY;
  253.     fwrite(&temp,4,1,fh);
  254.     ilbmfh->bodyLenOffset = ftell(fh);
  255.     temp = 0;
  256.     fwrite(&temp,4,1,fh);
  257.  
  258.     if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  259.       scanbuf = malloc(ilbmfh->scanLineWidth);
  260.     
  261.     switch( ilbmfh->format )
  262.     {
  263.       case FORMAT_BW:
  264.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  265.         {
  266.           if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  267.             fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[0].fh);
  268.           else
  269.             scanbuf = ilbmfh->buf[0].buf + scanLine*ilbmfh->scanLineWidth;
  270.  
  271.           if( pline == NULL )
  272.             fwrite(scanbuf,lineLen,1,fh);
  273.           else
  274.           {
  275.             psize = PackRow(scanbuf,pline,lineLen);
  276.             fwrite(pline,psize,1,fh);
  277.           }
  278.         }
  279.         break;
  280.       case FORMAT_GRAY:
  281.       case FORMAT_RED:
  282.       case FORMAT_GREEN:
  283.       case FORMAT_BLUE:
  284.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  285.         {
  286.           if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  287.             fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[0].fh);
  288.           else
  289.             scanbuf = ilbmfh->buf[0].buf + scanLine*ilbmfh->scanLineWidth;
  290.           for( bitNum = 0 ; bitNum < 8 ; bitNum++ )
  291.           {
  292.             makePlane(scanbuf,line,bitNum,lineLen,1);
  293.             if( pline == NULL )
  294.               fwrite(line,lineLen,1,fh);
  295.             else
  296.             {
  297.               psize = PackRow(line,pline,lineLen);
  298.               fwrite(pline,psize,1,fh);
  299.             }
  300.           }
  301.         }
  302.         break;
  303.       case FORMAT_RGB:
  304.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  305.         {
  306.           if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  307.             fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[0].fh);
  308.           else
  309.             scanbuf = ilbmfh->buf[0].buf + scanLine*ilbmfh->scanLineWidth;
  310.           for( bitNum = 0 ; bitNum < 24 ; bitNum++ )
  311.           {
  312.             makePlane(scanbuf,line,bitNum,lineLen,3);
  313.             if( pline == NULL )
  314.               fwrite(line,lineLen,1,fh);
  315.             else
  316.             {
  317.               psize = PackRow(line,pline,lineLen);
  318.               fwrite(pline,psize,1,fh);
  319.             }
  320.           }
  321.         }
  322.         break;
  323.       case FORMAT_RGB_RANDOM:
  324.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  325.         {
  326.           for( color = 0 ; color < 3 ; color++ )
  327.           {
  328.             if( ilbmfh->buf[color].buf )
  329.             {
  330.               if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  331.                 fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[color].fh);
  332.               else
  333.                 scanbuf = ilbmfh->buf[color].buf + scanLine*ilbmfh->scanLineWidth;
  334.               for( bitNum = 0 ; bitNum < 8 ; bitNum++ )
  335.               {
  336.                 makePlane(scanbuf,line,bitNum,lineLen,1);
  337.                 if( pline == NULL )
  338.                   fwrite(line,lineLen,1,fh);
  339.                 else
  340.                 {
  341.                   psize = PackRow(line,pline,lineLen);
  342.                   fwrite(pline,psize,1,fh);
  343.                 }
  344.               }
  345.             }
  346.           }
  347.         }
  348.         break;
  349.     }        
  350.     free(line);
  351.     if( pline )
  352.       free(pline);
  353.     if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  354.       free(scanbuf);
  355.  
  356.     for( color = 0 ; color < 3 ; color++ )
  357.     {
  358.       if( ilbmfh->buf[color].fh )
  359.         fclose(ilbmfh->buf[color].fh);
  360.       if( ilbmfh->buf[color].buf )
  361.         free(ilbmfh->buf[color].buf);
  362.     }
  363.  
  364.     // Write FORM and BODY length
  365.     formLen = ftell(fh) - ilbmfh->formLenOffset - 4;
  366.     bodyLen = ftell(fh) - ilbmfh->bodyLenOffset - 4;
  367.  
  368.     fseek(fh,ilbmfh->formLenOffset,SEEK_SET);
  369.     fwrite(&formLen,4,1,fh);
  370.  
  371.     fseek(fh,ilbmfh->bodyLenOffset,SEEK_SET);
  372.     fwrite(&bodyLen,4,1,fh);
  373.     
  374.     fclose(fh);
  375.   }
  376. }
  377.  
  378.  
  379. struct ILBMFile *openILBM(char* name,short compr,struct ScanInformation* info)
  380. {
  381.   struct ILBMFile* fh;
  382.   
  383.   if( fh = calloc(1,sizeof(struct ILBMFile)) )
  384.   {
  385.     fh->fileName = name;
  386.     if( compr )
  387.       fh->flags = ILBMFLAGS_COMPRESS;
  388.     else
  389.       fh->flags = 0;
  390.     fh->depth = info->sv_imageDepth;
  391.     fh->width = info->sv_imageWidth;
  392.     fh->height = info->sv_imageHeight;
  393.     fh->xdpi = (UWORD)(info->sv_xResolution+0.5);
  394.     fh->ydpi = (UWORD)(info->sv_yResolution+0.5);
  395.     fh->format = info->sv_lineFormat;
  396.     fh->scanLineWidth = info->sv_bytesPerLine;
  397.     fh->bufLen = fh->scanLineWidth*fh->height;
  398.     
  399.     switch( fh->format )
  400.     {
  401.       case FORMAT_BW:
  402.       case FORMAT_GRAY:
  403.       case FORMAT_RED:
  404.       case FORMAT_GREEN:
  405.       case FORMAT_BLUE:
  406.       case FORMAT_RGB:
  407.         if( fh->bufLen > ILBM_BUFLEN )
  408.           fh->bufLen = ILBM_BUFLEN;
  409.         fh->buf[0].buf = malloc(fh->bufLen);
  410.         break;
  411.       case FORMAT_RGB_RANDOM:
  412.         {
  413.           int c;
  414.           
  415.           if( 3*fh->bufLen > ILBM_BUFLEN )
  416.             fh->bufLen = ILBM_BUFLEN/3;
  417.             
  418.           for( c = 0 ; c < 3 ; c++ )
  419.             fh->buf[c].buf = malloc(fh->bufLen);
  420.         }
  421.         break;
  422.       default:
  423.         free(fh);
  424.         return NULL;
  425.     }
  426.   }
  427.         
  428.   return fh;
  429. }
  430.  
  431. void closeILBM(struct ILBMFile* ilbmfh,short error)
  432. {
  433.   int    c;
  434.   
  435.   if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  436.   {
  437.     for( c = 0 ; c < 3 ; c++ )
  438.     {
  439.       if( ilbmfh->buf[c].fh )
  440.       {
  441.         fwrite(ilbmfh->buf[c].buf,ilbmfh->buf[c].actualLen,1,ilbmfh->buf[c].fh);
  442.         fclose(ilbmfh->buf[c].fh);
  443.         // ilbmfh->buf[c].fh = NULL;
  444.       }
  445.     }
  446.   }
  447.  
  448.   if( !error )
  449.     makeILBM(ilbmfh);
  450.  
  451.   if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  452.   {
  453.     for( c = 0 ; c < 3 ; c++ )
  454.       remove(tempfile[c]);
  455.   }
  456.  
  457.   free(ilbmfh);
  458. }
  459.  
  460. void writeILBM(struct ILBMFile* fh,struct ScanLine* line)
  461. {
  462.   int cPlane;
  463.   
  464.   if( fh->format == FORMAT_RGB_RANDOM )
  465.   {
  466.     switch( line->sl_color )
  467.     {
  468.       case FORMAT_RED:
  469.         cPlane = 0;
  470.         break;
  471.       case FORMAT_GREEN:
  472.         cPlane = 1;
  473.         break;
  474.       case FORMAT_BLUE:
  475.         cPlane = 2;
  476.         break;
  477.       default:
  478.         return;
  479.     }
  480.   }
  481.   else
  482.     cPlane = 0;
  483.       
  484.   if( fh->buf[cPlane].actualLen + fh->scanLineWidth > fh->bufLen )
  485.   {
  486.     if( fh->buf[cPlane].fh == NULL )
  487.     {
  488.       if( fh->buf[cPlane].fh = fopen(tempfile[cPlane],"w") )
  489.         fh->flags |= ILBMFLAGS_TEMPFILE;
  490.       else
  491.         return;
  492.     }
  493.           
  494.     fwrite(fh->buf[cPlane].buf,fh->buf[cPlane].actualLen,1,fh->buf[cPlane].fh);
  495.     fh->buf[cPlane].actualLen = 0;
  496.   }
  497.  
  498.   memcpy(fh->buf[cPlane].buf+fh->buf[cPlane].actualLen,line->sl_data,fh->scanLineWidth);
  499.   fh->buf[cPlane].actualLen += fh->scanLineWidth;
  500. }
  501.